import axios from '@/utils/request';

export const FNFundGroup = (): any => {
    const tpme = GET_CACHE('FundGroup');
    if (tpme) {
        return Promise.resolve(tpme);
    }

    // 传false,默认展示全部，不传（默认true），会排除掉导出类型为不导出的那些外部产品组
    return new Promise((resolve, reject) => {
        axios
            .post('/fundGroup/list?filterNoImportType=false')
            .then(res => {
                if (res) {
                    SET_CACHE('FundGroup', res);
                    resolve(res);
                }
            })
            .catch(error => {
                reject(error);
            });
    });
};
// 删除
export const DELETE_CACHE = (cacheName: string): void => {
    sessionStorage.removeItem(cacheName);
};

// 存
export const SET_CACHE = (cacheName: string, obj: any): void => {
    if (!cacheName || !obj) {
        return;
    }
    sessionStorage.setItem(cacheName, JSON.stringify(obj));
};

// 取
export const GET_CACHE = (cacheName: string): any => {
    return JSON.parse(sessionStorage.getItem(cacheName)) || null;
};

// 根据url获取缓存并存储 使用get方式请求
export const SGU_CACHE = async (cacheName, url, defaultFalue, operateType?) => {
    let temp = GET_CACHE(cacheName);
    if (temp) {
        return temp;
    }
    temp = await awaitAxios(url, operateType);
    SET_CACHE(cacheName, temp);
    return temp || defaultFalue;
};

export const awaitAxios = (url, operateType?) => {
    return new Promise((resolve, reject) => {
        axios({ url: url, headers: { operateType: operateType } }).then(res => {
            resolve(res);
        });
    });
};

export const objToArr = param => {
    const list = [];
    for (const key in param) {
        list.push({ dictKey: key, dictKeyName: param[key] });
    }
    return list;
};

// 删除localStorage
export const DELETE_LOCAL_CACHE = (cacheName: string): void => {
    localStorage.removeItem(cacheName);
};

// 存localStorage
export const SET_LOCAL_CACHE = (cacheName: string, obj: any): void => {
    if (!cacheName || !obj) {
        return;
    }
    localStorage.setItem(cacheName, JSON.stringify(obj));
};

// 取localStorage
export const GET_LOCAL_CACHE = (cacheName: string): any => {
    return JSON.parse(localStorage.getItem(cacheName)) || null;
};
export default class DictionConstUtil {
    /**
     * 集合转对象
     */
    static ListToPojo = (param: any) => {
        const pojo = {};
        for (let i = 0; i < param.length; i++) {
            pojo[param[i].dictKey] = param[i].dictKeyName;
        }
        return pojo;
    };

    /**
     * 集合转对象2 已集合中的某个字段作为key value=对象
     */
    static ListToPojo2 = (key: any, param: any) => {
        const pojo = {};
        for (let i = 0; i < param.length; i++) {
            pojo[param[i][key]] = param[i];
        }
        return pojo;
    };

    /**
     * 集合转对象3 已集合中的某个字段作为key value=对象
     */
    static ListToPojo3 = (key: any, param: any, key2: any) => {
        const pojo = {};
        for (let i = 0; i < param.length; i++) {
            pojo[param[i][key]] = param[i][key2];
        }
        return pojo;
    };

    /**
     *  反转对象键值
     */
    static ReversePojo = obj => {
        const pojo = {};
        for (const key of Object.keys(obj)) {
            pojo[obj[key]] = key;
        }
        return pojo;
    };

    /**
     * 对象转集合
     */
    static PojoToList = (param: any) => {
        const list = [];
        for (const key in param) {
            list.push({ dictKey: key, dictKeyName: param[key] });
        }
        return list;
    };

    /**
     * 对象转集合2
     */
    static PojoToList2 = (param: any) => {
        const list = [];
        for (const key in param) {
            list.push({ value: Number(key), label: param[key] });
        }
        return list;
    };

    /**
     * 对象转集合3
     */
    static PojoToList3 = (param: any) => {
        const list = [];
        for (const key in param) {
            list.push({ value: key, label: param[key] });
        }
        return list;
    };

    /**
     * 证券范围信息(根据范围属性)
     */
    static FNBoundCfgByBoundType = (boundType: string) => {
        return new Promise((resolve, reject) => {
            axios('/original/list/' + boundType)
                .then((res: any) => {
                    resolve(res);
                })
                .catch(error => {
                    reject(error);
                });
        });
    };

    /**
     * 获取市场类型
     */
    static FNMarketType = () => {
        return SGU_CACHE('MarketType', '/dict/market/list', []);
    };
    /**
     * 获取证券类别
     */
    static FNStockType = () => {
        return SGU_CACHE('StockType', '/dict/stockType/list', []);
    };

    /**
     * 产品信息
     */
    static FNFundInfo = () => {
        return SGU_CACHE('FundInfo', '/fundInfo/list', []);
    };

    /**
     * 自定义风险分类
     */
    static FNCustomType = () => {
        return SGU_CACHE('CustomType', '/dict/list/code/Y_000157', []);
    };

    static getDictAll = () => {
        return SGU_CACHE('DictionaryCodes', '/dict/listAll', []);
    };

    /**
     * 获取业务品种
     */
    static FNCateGory = () => {
        return SGU_CACHE('cateGory', '/dict/cateGory/alllist', []);
    };

    /**
     * 获取前端过滤类型 c_web_filter_type
     */
    static FNWebFilterType = () => {
        return SGU_CACHE('WebFilterType', '/dict/list/code/Y_000209', []);
    };

    /**
     * 取出(FN) 证券范围信息
     */
    static FNBoundCfg = () => {
        const temp = GET_CACHE('BoundCfg');
        if (temp) {
            return Promise.resolve(temp);
        }
        return new Promise((resolve, reject) => {
            axios('/original/list')
                .then((res: any) => {
                    if (res) {
                        SET_CACHE('BoundCfg', res);
                        resolve(res);
                    }
                })
                .catch(error => {
                    reject(error);
                });
        });
    };

    /**
     * 存(SGU) 证券范围信息
     */
    static SGUBoundCfg = () => {
        return new Promise((resolve, reject) => {
            axios('/original/list')
                .then((res: any) => {
                    if (res) {
                        SET_CACHE('BoundCfg', res);
                        resolve(res);
                    }
                })
                .catch(error => {
                    reject(error);
                });
        });
    };

    /**
     * 分支模板
     */
    static FNBranchTemplate = () => {
        const temp = GET_CACHE('BranchTemplate');
        if (temp) {
            return Promise.resolve(temp);
        }
        return new Promise((resolve, reject) => {
            axios
                .post('/entry/template/branch/list', {
                    data: {
                        paging: {
                            // 分页
                            total: 0,
                            currentPage: 1,
                            totalPage: 0,
                            pageSize: 10000,
                        },
                        type: '1',
                    },
                })
                .then((res: any) => {
                    if (res) {
                        SET_CACHE('BranchTemplate', res.list);
                        resolve(res.list);
                    }
                })
                .catch(error => {
                    reject(error);
                });
        });
    };

    static FNBranchTemplate2 = () => {
        const temp = GET_CACHE('DetailsBranchTemplate');
        if (temp) {
            return Promise.resolve(temp);
        }
        return new Promise((resolve, reject) => {
            axios
                .post('/entry/template/branch/list', {
                    data: {
                        paging: {
                            // 分页
                            total: 0,
                            currentPage: 1,
                            totalPage: 0,
                            pageSize: 10000,
                        },
                    },
                })
                .then((res: any) => {
                    if (res) {
                        SET_CACHE('DetailsBranchTemplate', res.list);
                        resolve(res.list);
                    }
                })
                .catch(error => {
                    reject(error);
                });
        });
    };

    /**
     * 刷新分支模板
     */
    static FNBranchTemplateList = () => {
        return new Promise((resolve, reject) => {
            axios
                .post('/entry/template/branch/list', {
                    data: {
                        paging: {
                            // 分页
                            total: 0,
                            currentPage: 1,
                            totalPage: 0,
                            pageSize: 10000,
                        },
                        // type: '1',
                    },
                })
                .then((res: any) => {
                    if (res) {
                        SET_CACHE('DetailsBranchTemplate', res.list);
                        resolve(res.list);
                    }
                })
                .catch(error => {
                    reject(error);
                });
        });
    };

    /**
     * 取出(FN) 计算因子信息
     */
    static FNCalculateFactor = () => {
        const temp = GET_LOCAL_CACHE('CalculateFactor');
        if (temp) {
            return Promise.resolve(temp);
        }
        return new Promise((resolve, reject) => {
            axios
                .post('/entry/calcFactor/all')
                .then((res: any) => {
                    if (res) {
                        SET_LOCAL_CACHE('CalculateFactor', res);
                        resolve(res);
                    }
                })
                .catch(error => {
                    reject(error);
                });
        });
    };

    /**
     * 存(SGU) 计算因子信息
     */
    static SGUCalculateFactor = () => {
        return new Promise((resolve, reject) => {
            axios
                .post('/entry/calcFactor/all')
                .then((res: any) => {
                    if (res) {
                        SET_LOCAL_CACHE('CalculateFactor', res);
                        resolve(res);
                    }
                })
                .catch(error => {
                    reject(error);
                });
        });
    };

    static FNFundGroup = () => {
        const tpme = GET_CACHE('FundGroup');
        if (tpme) {
            return Promise.resolve(tpme);
        }

        // 传false,默认展示全部，不传（默认true），会排除掉导出类型为不导出的那些外部产品组
        return new Promise((resolve, reject) => {
            axios
                .post('/fundGroup/list?filterNoImportType=false')
                .then(res => {
                    if (res) {
                        SET_CACHE('FundGroup', res);
                        resolve(res);
                    }
                })
                .catch(error => {
                    reject(error);
                });
        });
    };
    /**
     * 分支范围模板
     */
    static FNBranchBoundTemplate = () => {
        const temp = GET_CACHE('BranchBoundTemplate');
        if (temp) {
            return Promise.resolve(temp);
        }

        return new Promise((resolve, reject) => {
            axios
                .post('/entry/template/branch/list', {
                    data: {
                        paging: {
                            // 分页
                            total: 0,
                            currentPage: 1,
                            totalPage: 0,
                            pageSize: 10000,
                        },
                        type: '2',
                    },
                })
                .then((res: any) => {
                    if (res) {
                        SET_CACHE('BranchBoundTemplate', res.list);
                        resolve(res.list);
                    }
                })
                .catch(error => {
                    reject(error);
                });
        });
    };

    /**
     * 表说明信息
     */
    static FNTableComment = () => {
        return SGU_CACHE('TableComment', '/original/table/comment', []);
    };

    static FNUserAccount = () => {
        return SGU_CACHE('UserAccount', '/entry/checkentry/checkquery', []);
    };

    /**
     * 获取指令数据来源类型
     */
    static FNInstructionDataSourceType = () => {
        return SGU_CACHE('InstructionDataSourceType', '/dict/list/code/Y_000126', []);
    };

    static UserDefinedCode = () => {
        return SGU_CACHE('UserDefined', '/dict/list/code/Y_000255', []);
    };

    // 产品组合信息
    static FNFundAccount = () => {
        return SGU_CACHE('FundAccount', '/fundInfo/accounts', []);
    };
    /*
     * 查询交易方向信息
     */
    static FNTradeDirection = () => {
        return SGU_CACHE('TradeDirection', '/dict/tradeDirections', []);
    };

    /**
     * 产品代码转产品显示代码
     */
    static FNFundShowCode = async fundCode => {
        let temp = GET_CACHE('FundShowCodes');
        if (temp) {
            return temp[fundCode];
        }
        const fundInfos = await DictionConstUtil.FNFundInfo();
        temp = {};
        fundInfos.forEach(item => {
            temp[item.fundCode] = item.showCode;
        });
        SET_CACHE('FundShowCodes', temp);
        return temp[fundCode] || '';
    };

    /**
     * 刷新范围模板
     */
    static FNBranchBoundTemplateRefresh = () => {
        return new Promise((resolve, reject) => {
            axios
                .post('/entry/template/branch/list', {
                    data: {
                        paging: {
                            // 分页
                            total: 0,
                            currentPage: 1,
                            totalPage: 0,
                            pageSize: 10000,
                        },
                        type: '2',
                    },
                })
                .then((res: any) => {
                    if (res) {
                        SET_CACHE('BranchBoundTemplate', res.list);
                        resolve(res.list);
                    }
                })
                .catch(error => {
                    reject(error);
                });
        });
    };

    static UnitFilter = {
        '0': ['无', '%', '万元', '元'],
        '1': ['无', '%', '万股'],
        '2': ['无', '%', '万股', '万元', '元', '年', '天'],
        '3': ['无', '%', '万元', '元'],
        '4': ['无', '天', '年'],
        '5': ['无', '%', '万元', '元'],
        '6': ['%', '万股', '万元', '元'],
        '7': ['无'],
        '8': ['无', '%', '万股', '万元', '元'],
        '9': ['无', '%'],
        '10': ['无', '%', '万元', '元'],
        '11': ['无', '%', '万元', '元'],
    } as const;

    static OriginalAccountType = {
        '0': '产品',
        '1': '产品组',
    } as const;
    // static SignleOriginalAccountType = {
    //     '0': '产品',
    //     '1': '产品组',
    // } as const;
    /**
     * 条目状态
     */
    static EntryStatus = {
        '0': '禁用',
        '1': '启用',
    } as const;
    /**
     * 风险等级
     */
    static ControlGrade = {
        '0': '法律规定',
        '1': '公司规定',
        '2': '其他规定',
        '3': '契约规定',
    } as const;
    /**
     * 风险等级 (cmschina)
     */
    static ControlGrade2 = {
        '0': '法律规定',
        '1': '公司规定',
        '2': '其他规定',
        '3': '契约规定',
        '4': '授权管理',
    } as const;
    // 比较
    static ControlDirection = {
        '1': '大于',
        '2': '小于',
        '3': '等于',
        '4': '大于等于',
        '5': '小于等于',
        '6': '不等于',
    } as const;
    /**
     * 控制类型
     */
    static AccountControlType = {
        '0': '单产品控制',
        '1': '多产品控制',
        '2': '产品组内联合控制',
        '3': '产品组间联合控制',
        '4': '单产品、多产品联合控制',
        '5': '产品组内单、多产品联合控制',
        '6': '产品组间单、多产品联合控制',
    } as const;
    /**
     * 条目关系类型
     */
    static RiskRelation = {
        '0': '联合',
        '1': '互斥',
    } as const;
    /**
     * 投资风险设置=》自定义设置
     */
    static UserDefined = {
        '1': '基金经理/投资经理',
        '2': '部门负责人',
        '3': '分管领导',
        '4': '投决会',
    } as const;
    /**
     * 复核事件类型
     */
    static RiskModifyType = {
        '1': '新增条目',
        '2': '修改条目',
        '3': '删除条目',
        '4': '状态修改',
        '5': '条目同步',
    } as const;
    /**
     * 条目备份类型
     */
    static EntryHistoryType = {
        '1': '修改备份',
        '2': '删除备份',
        '3': '恒生删除',
        '4': '同步失败删除',
    } as const;
    /**
     * 条目类型参数
     */
    static EntryTypeParam = {
        '1': '账户原始序号设置',
        '2': '账户控制值设置',
        '3': '排除账户设置',
        '4': '排除账户组控制',
    } as const;
    /**
     * 控制模式 该条件作为大前提条件
     */
    static ControlModel = {
        '0': '不做控制',
        '1': '不能有买有卖',
        '2': '不允许买价>=卖价',
        '3': '未成委托/指令不允许有买有卖',
        '4': '未成部分不允许买价>=卖价',
        // "5": "同向控制",
        // "6": "ETF一二级市场不允许反向",
        // "7": "期货市场不允许反向开仓",
        // "8": "期货当日不能先开后平",
        '9': '不允许劣于均价',
    } as const;
    /**
     * 条目参数类型
     */
    static ParamType = {
        '1': '账户原始序号设置',
        '2': '账户控制值设置',
        '3': '排除账户设置',
        '4': '排除账户组设置',
        '5': '豁免次数',
        '6': '比较天数',
        '7': '控制模式',
        '8': '单向控制',
        '9': '按绝对值控制',
        a: '启用时段',
        // "b": "启用时段-结束",
        c: '是否买入控涨',
        d: '是否卖出控跌',
        e: '业务方向',
    } as const;

    /**
     * 条目权限参数类型
     */
    static EntryRole = {
        '001': '风控',
        '002': '投资',
        '003': '交易',
        '004': '合规风险',
    } as const;

    static entryRole = [
        { key: '001', entryRoleCode: '001', entryRoleName: '风控', createUser: 'liaodehai', createDate: '20211122', createTime: '00:15:00' },
        { key: '002', entryRoleCode: '002', entryRoleName: '投资', createUser: 'liaodehai', createDate: '20211122', createTime: '00:15:00' },
        { key: '003', entryRoleCode: '003', entryRoleName: '交易', createUser: 'liaodehai', createDate: '20211122', createTime: '00:15:00' },
        { key: '004', entryRoleCode: '004', entryRoleName: '合规风险', createUser: 'liaodehai', createDate: '20211122', createTime: '00:15:00' },
    ] as const;

    /**
     * 数据来源信息
     */
    static SourceType = {
        '1': '风控',
        '2': '恒生-主动',
        '3': '财汇',
        '5': '恒生-被动',
        '6': '数据中心',
        '7': '万得',
    } as const;
    /**
     * 比较方向 适用于范围配置
     */
    static CompareDirection = {
        '0': '大于',
        '1': '小于',
        '2': '大于等于',
        '3': '小于等于',
        '4': '等于',
        '5': '不等于',
        '6': '无',
    } as const;
    /**
     * SQL拼接连接符
     */
    static SqlSplicingType = {
        '0': '并且',
        '1': '或者',
        '2': '并且-取反',
        '3': '或者-取反',
    } as const;
    /**
     * 计算方向 / 作用范围
     */
    static RiskCalType = {
        '0': '静态',
        '1': '指令',
        '2': '委托',
    } as const;
    /**
     * 计算方向 枚举类型
     */
    static RiskCalSqlType = {
        '0': '持仓',
        '1': '指令',
        '2': '委托',
        '3': '静态',
    } as const;
    static ThresholdType = {
        '0': '合规',
        '1': '警告',
        '2': '送审',
        '3': '禁止',
        '4': '错误',
    } as const;
    /**
     * 利率类型
     */
    static InterestType = {
        '0': '零息',
        '1': '固定利率',
        '2': '浮动利率',
    } as const;
    /**
     * 下单类型
     */
    static OrderType = {
        '1': '试算',
        '2': '下单',
    } as const;
    /**
     * 批量下单模式
     */
    static DirectMode = {
        '1': '一笔失败触警',
        '2': '能下则下',
    } as const;
    /**
     * 证券范围 值下拉列表数据类型
     * 后台数据字段 Y_000058
     */
    static StockBoundCfgValueType = {
        '0': '下拉列表数据-多选',
        '1': '数字输入框-整数',
        '2': '大数据选择',
        '3': '时间选择框',
        '4': '下拉列表数据-单选',
        '5': '数字输入框-小数',
    } as const;
    /**
     * 分支拼接符
     */
    static RiskEntryBranchSplicingType = {
        '0': '加上',
        '1': '减去',
        '2': '乘以',
        '3': '除以',
        '4': '绝对值',
        '5': '轧差(取负)',
        '6': '轧差(取正)',
        '7': '减去(日期)',
        '8': '减去(交易日期)',
        '9': '最大值',
        '10': '其中',
    } as const;
    /**
     * 分支类型
     */
    static RiskEntryBranchType = {
        '0': '普通分支',
        '1': '组分支',
    } as const;
    /**
     * 范围属性类型
     */
    static BoundType = {
        '0': '基金属性组配置',
        '1': '投资属性组配置',
        '2': '银行属性组配置',
        '3': '证券属性组配置',
        '4': '对手方属性组配置',
        '5': '银行查看组配置', // 银行属性组配置 下的子属性
        '6': '证券查看组配置', // 证券属性组配置 下的子属性
        '7': '对手方查看组配置', // 对手方属性组配置 下的子属性
        '8': '穿透证券属性配置',
        '10': '穿透银行属性配置',
        '11': '穿透证券属性组配置',
        '12': '衍生品属性组配置',
        // '13': '衍生品属性查看组配置',
    } as const;

    static BoundType1 = {
        '0': '基金属性组配置',
        '1': '投资属性组配置',
        '2': '银行属性组配置',
        '3': '证券属性组配置',
        '4': '对手方属性组配置',
        '8': '穿透证券属性配置',
        '10': '穿透银行属性配置',
        '11': '穿透证券属性组配置',
        '12': '衍生品属性组配置',
        // '13': '衍生品属性查看组配置',
    } as const;

    static BoundTypeForTable = {
        '0': 'DD',
        '1': 'CC',
        '2': 'HDB',
        '3': 'ZQXX',
        '4': 'OPPO',
        '8': 'ZQXX',
        '10': 'HDB',
    } as const;
    /**
     * 银行分类1
     */
    static BankType = {
        '-2': '空',
        '1': '国有商业银行',
        '2': '股份制商业银行',
        '3': '城商行',
        '4': '农商行',
    } as const;
    /**
     * 计算因子 变动类型
     */
    static FactorChangeType = {
        '0': '没有变动',
        '1': '变动数据行数',
        '2': '变动数据值',
    } as const;
    /**
     * 计算因子 变动类型 enum
     */
    static FactorChangeTypeEnum = {
        NO_CHANGE: '没有变动',
        CHANGE_DATA: '变动数据行数',
        CHANGE_VALUE: '变动数据值',
    } as const;
    /**
     * 风控类型
     */
    static EntryType = {
        '0': '资产类',
        '1': '数量类',
        '2': '指标控制类',
        '3': '同向反向控制',
        '4': '时间期限类',
        '5': '范围控制类',
        '6': '交易额控制类',
        '8': '单笔控制',
        '9': '单一行业权重控制',
        '10': '个数控制类',
        '11': '触发控制类'
    } as const;

    /**
     * 复核类型
     */
    static modifyStatus = {
        '1': '待复核',
        '2': '复核通过',
        '3': '复核拒绝',
        '4': '废弃',
    } as const;

    // 换成接口获取 FNCateGory
    // static Category = {
    //     JJ: '基金',
    //     QZ: '权证',
    //     CK: '存款',
    //     CP: '理财',
    //     GP: '股票',
    //     HG: '回购',
    //     ZQ: '债券',
    //     QH: '期货',
    //     QT: '其它',
    // } as const;
    /**
     * 基金类型
     */
    static FundType = {
        '1': '公募',
        '2': '年金',
        '3': '专户',
        '8': '年金2',
        '9': '专户理财2',
        i: '投顾',
    } as const;
    /**
     * 撤单类型 下单时传递的参数
     */
    static CancelType = {
        '1': '错误/禁止撤单',
        '2': '送审撤单',
        '3': '警告撤单',
        '4': '不撤单',
    } as const;
    /**
     * 项目标识 区分是否是项目
     */
    static ProjectSymbolType = {
        '0': '产品',
        '1': '项目',
    } as const;
    static CalRelations = {
        '0': '否',
        '1': '是',
    } as const;
    static CalFactorChangeType = {
        '1': '数据变动',
        '2': '行情变动',
    } as const;

    // 指令状态
    static instStatusType = {
        '0': '已归档',
        '1': '已下达成功',
        '3': '已撤销',
    } as const;

    // 分红方式
    static bonusType = {
        '1': '现金分红',
        '2': '分红再投资',
    } as const;

    // 收费方式
    static feeType = {
        '1': '前收费',
        '2': '后收费',
    } as const;

    // 可转入、转出证券状态
    static stockStatus = {
        '1': '正常',
        '2': '停牌',
    } as const;

    // 账户层次
    static RemoldOriginalAccountType = {
        '0': '产品',
        '1': '产品组',
        '2': '资产单元',
        '3': '资产单元组',
        '4': '投资组合',
        '5': '投资组合组',
    } as const;

    // 账户类型
    static RemoldAccountControlType = {
        '0': '单产品控制',
        '1': '多产品控制',
        '2': '产品组内联合控制',
        '3': '产品组间联合控制',
        '7': '单资产单元控制',
        '8': '多资产单元联合控制',
        '9': '资产单元组内资产单元联合控制',
        '10': '资产单元组间资产单元联合控制',
        '11': '资产单元组内按基金联合控制',
        '12': '单组合控制',
        '13': '多组合联合控制',
        '14': '投资组合组组内投资组合联合控制',
        '15': '投资组合组组间投资组合联合控制',
        '4': '单产品、多产品联合控制',
        '5': '产品组内单、多产品联合控制',
        '6': '产品组间单、多产品联合控制',
        '16': '单资产单元、多资产单元联合控制',
        '17': '资产单元组内单、多资产单元联合控制',
        '18': '资产单元组间单、多资产单元联合控制',
        '19': '单投资组合、多投资组合联合控制',
        '20': '投资组合组内单、多投资组合联合控制',
        '21': '投资组合组间单、多投资组合联合控制',
    } as const;

    // 条目配置需要提示的计算因子(计算维度为证券)
    static verifyCalfactor = {
        YH006: '证券总股本',
        YH010: '发行人净资产',
        YH011: '银行发行人净资产',
        YH012: '证券流通股本',
        YH015: '发行人总资产',
        YH016: '银行发行人总资产',
        YH047: '证券总股本市值',
        YH048: '证券流通股本市值',
        YH057: '历史交易金额',
        YH058: '历史交易数量',
        YH059: '历史交易面值',
        YH060: '证券本次发行量',
        YH063: '银行发行人净资本',
        YH064: '发行人总负债',
        YH081: '期货市场持仓总量',
        YH086: '恒生行业权重',
        YH087: '社保行业权重',
        YH089: '发行人预收账款',
        YH090: '发行人商誉',
        YH091: '发行人永续债',
        YH092: '证券发行规模：元',
        YH105: '当日市场成交数量',
        YH146: '证券基金净资产',
        YH150: '发行人永续债',
        YH151: '发行人商誉',
        YH152: '发行人预收账款',
        YH153: '发行人总负债',
        YH154: '发行人总资产',
        YH170: '流水范围控制',
        YH214: '基金未来现金流金额',
        YH219: '基金持有人持有份额',
        YH220: '基金销售渠道份额',
        YH221: '基金持有人持有份额：含一致行动人',
        YH222: '基金申购款：T日净申购',
        YH224: '集合债发行人净资产：上年末孰低',
        YH226: '发行人净资产:上年末',
        YH264: '债券发行余额',
        YH274: '中债登推荐收益率',
        YH275: '债券持仓估价基点价值',
        YH318: '中债登推荐收益率',
        YH320: '证券待交割资产：当日',
        YH325: '证券投资基金净资产:上季末',
        YH330: '交易对手净资产',
        YH355: '证券近十二个月日均换手率(%)',
        YH408: '近期披露净值',
        YH438: '对标指数成分股权重',
        YH480: '银行上一年度总资产',
        YH481: '银行上一年度资本金',
        YH485: '发行主体授信额度',
        ZY012: '债券发行余额(数量)',
    } as const;

    // 目标类型
    static targetType = {
        '1': '绝对数量',
        '2': '绝对金额',
    } as const;
    /* *************************************字典部分 -- 字典颜色 *************************************** */
    static ThresholdTypeColor = {
        '0': '#95f204',
        '1': '#f59a23',
        '2': '#ffff00',
        '3': '#d9001b',
        '4': '#333333',
    } as const;
    /* *************************************函数部分 --基金/证券类别/市场类型/基金组/表说明/模板相关/风险类型 ****************************************/

    /* *************************************字典部分 -- 低中高 字典颜色 ****************************************/
    static LevelType = {
        '1': {
            color: '#eaea52',
            label: '低',
        },
        '2': {
            color: '#ee7d01',
            label: '中',
        },
        '3': {
            color: '#ff0000',
            label: '高',
        },
    } as const;
}
